const S7Connector = require('./plc/s7-connector');
const fs = require('fs').promises;
const path = require('path');

class PLCService {
  constructor() {
    this.isConnected = false;
    this.connector = null;
    this.config = null;
    this.groups = null;
    this.requestQueue = [];
    this.isProcessing = false;
    this.processingInterval = null;
    this.processingIntervalTime = 50; // 添加处理循环间隔时间，默认100ms
    // 添加历史记录数组
    this.history = [];
  }

  // 加载PLC配置文件
  async loadConfig() {
    try {
      const configPath = path.join(__dirname, '../public/plc-config.json');
      const configFile = await fs.readFile(configPath, 'utf8');
      this.config = JSON.parse(configFile);
      console.log('✅ PLC配置文件加载成功');
      return this.config;
    } catch (err) {
      console.error('❌ PLC配置文件加载失败:', err);
      // 使用默认配置
      this.config = {
        "plcType": "S7-1200",
        "connection": {
          "host": "192.168.0.1",
          "port": 102,
          "rack": 0,
          "slot": 1,
          "timeout": 5000
        },
        "variables": [],
        "readInterval": 1000
      };
      return this.config;
    }
  }

  // 加载分组配置文件列表 - 新增方法
  async loadGroupFiles() {
    try {
      const groupsDir = path.join(__dirname, '../public/plc-groups');
      const files = await fs.readdir(groupsDir);
      this.groupFiles = files.filter(file => file.endsWith('.json'));
      console.log('✅ PLC分组文件列表加载成功:', this.groupFiles);
      console.log('📁 分组文件总数:', this.groupFiles.length);
      return this.groupFiles;
    } catch (err) {
      console.error('❌ PLC分组文件列表加载失败:', err);
      this.groupFiles = [];
      return this.groupFiles;
    }
  }

  // 加载指定分组配置文件 - 新增方法
  async loadGroupFile(groupId) {
    try {
      const groupFilePath = path.join(__dirname, '../public/plc-groups', `${groupId}.json`);
      const groupFile = await fs.readFile(groupFilePath, 'utf8');
      const group = JSON.parse(groupFile);
      console.log(`✅ PLC分组配置文件 ${groupId} 加载成功`);
      return group;
    } catch (err) {
      console.error(`❌ PLC分组配置文件 ${groupId} 加载失败:`, err);
      throw new Error(`无法加载分组配置文件 ${groupId}: ${err.message}`);
    }
  }

  // 加载所有分组配置 - 新增方法
  async loadAllGroups() {
    try {
      // 先加载分组文件列表
      await this.loadGroupFiles();
      
      // 加载所有分组配置
      const groups = [];
      for (const file of this.groupFiles) {
        try {
          const groupFilePath = path.join(__dirname, '../public/plc-groups', file);
          const groupFile = await fs.readFile(groupFilePath, 'utf8');
          const group = JSON.parse(groupFile);
          groups.push(group);
        } catch (err) {
          console.error(`❌ 加载分组文件 ${file} 失败:`, err);
        }
      }
      
      this.groups = { groups };
      console.log('✅ 所有PLC分组配置加载成功');
      return this.groups;
    } catch (err) {
      console.error('❌ 所有PLC分组配置加载失败:', err);
      this.groups = { groups: [] };
      return this.groups;
    }
  }

  // 初始化PLC连接
  async init(plcConfig = null) {
    try {
      // 如果已经有连接，先断开
      if (this.connector) {
        console.log('🔄 断开现有PLC连接...');
        this.connector.disconnect();
      }
      
      // 如果没有提供配置，则加载配置文件
      if (!plcConfig) {
        await this.loadConfig();
        plcConfig = this.config.connection;
      } else if (this.config) {
        // 如果提供了配置且已有配置文件，合并配置
        plcConfig = { ...this.config.connection, ...plcConfig };
      }

      console.log('🔄 正在初始化PLC连接，配置:', plcConfig);
      
      this.connector = new S7Connector(plcConfig);
      
      // 监听连接事件
      this.connector.on('connected', () => {
        this.isConnected = true;
        console.log('✅ PLC服务已连接');
        
        // 连接成功后，启动统一处理循环
        this.startProcessingLoop();
        
        // 连接成功后，自动启动周期性读取（如果配置了）
        if (this.config && this.config.variables && this.config.readInterval) {
          const variables = this.config.variables.map(v => v.name);
          this.setReadInterval(variables, this.config.readInterval);
          console.log(`✅ 已启动周期性读取，间隔: ${this.config.readInterval}ms`);
        }
      });
      
      this.connector.on('disconnected', () => {
        this.isConnected = false;
        console.log('❌ PLC服务已断开');
        // 停止处理循环
        this.stopProcessingLoop();
      });
      
      this.connector.on('error', (err) => {
        console.error('❌ PLC连接错误:', err);
        this.isConnected = false;
        // 停止处理循环
        this.stopProcessingLoop();
      });
      
      this.connector.on('data', (data) => {
        console.log('📥 PLC数据更新:', data);
        // 可以在这里处理数据更新事件
      });
      
      // 尝试连接，最多重试3次
      let connectAttempts = 0;
      const maxConnectAttempts = 3;
      let connected = false;
      
      while (connectAttempts < maxConnectAttempts && !connected) {
        connectAttempts++;
        try {
          console.log(`🔄 尝试连接PLC (${connectAttempts}/${maxConnectAttempts})...`);
          await this.connector.connect();
          connected = true;
          console.log('✅ PLC连接初始化完成，连接状态:', this.isConnected);
        } catch (connectErr) {
          console.error(`❌ PLC连接尝试 ${connectAttempts}/${maxConnectAttempts} 失败:`, connectErr);
          
          if (connectAttempts < maxConnectAttempts) {
            // 等待一段时间后重试
            const retryDelay = 2000;
            console.log(`⏱️  ${retryDelay}ms 后重试...`);
            await new Promise(resolve => setTimeout(resolve, retryDelay));
          }
        }
      }
      
      this.isConnected = connected;
      return this.isConnected;
    } catch (err) {
      console.error('❌ PLC初始化失败:', err);
      this.isConnected = false;
      return false;
    }
  }

  // 启动统一处理循环
  startProcessingLoop() {
    // 如果已有处理循环，先停止
    if (this.processingInterval) {
      clearInterval(this.processingInterval);
    }
    
    // 启动新的处理循环
    this.processingInterval = setInterval(() => {
      this.processRequestQueue();
    }, this.processingIntervalTime);
    
    console.log(`✅ 启动PLC统一处理循环，处理间隔: ${this.processingIntervalTime}ms`);
  }

  // 停止统一处理循环
  stopProcessingLoop() {
    if (this.processingInterval) {
      clearInterval(this.processingInterval);
      this.processingInterval = null;
      console.log('🛑 停止PLC统一处理循环');
    }
  }

  // 修改处理请求队列的方法，添加历史记录
  async processRequestQueue() {
    if (this.isProcessing || this.requestQueue.length === 0) {
      return;
    }

    this.isProcessing = true;

    try {
      // 处理读取请求（批量处理）
      const readRequests = this.requestQueue.filter(req => req.type === 'read');
      const readGroupRequests = this.requestQueue.filter(req => req.type === 'readGroup');
      const writeRequests = this.requestQueue.filter(req => req.type === 'write');
      
      // 清空已处理的请求
      this.requestQueue = this.requestQueue.filter(req => 
        req.type !== 'read' && req.type !== 'readGroup' && req.type !== 'write'
      );
      
      // 处理读取请求（按变量分组批量处理）
      for (const request of readRequests) {
        try {
          console.log(`📥 统一读取变量:`, request.variables);
          const values = await this.readVariablesInternal(request.variables);
          
          // 添加到历史记录
          this.history.push({
            id: Date.now() + Math.random().toString(36).substr(2, 9),
            type: 'read',
            variables: request.variables,
            result: values,
            status: 'completed',
            timestamp: Date.now()
          });
          
          if (request.resolve) {
            request.resolve(values);
          }
        } catch (err) {
          console.error(`❌ 变量读取失败:`, err);
          
          // 添加到历史记录
          this.history.push({
            id: Date.now() + Math.random().toString(36).substr(2, 9),
            type: 'read',
            variables: request.variables,
            error: err.message,
            status: 'failed',
            timestamp: Date.now()
          });
          
          if (request.reject) {
            request.reject(err);
          }
        }
      }
      
      // 处理分组读取请求
      for (const request of readGroupRequests) {
        try {
          console.log(`📥 统一分组读取:`, request.groupId);
          const groupValues = await this.readGroupVariablesInternal(request.groupId);
          
          // 添加到历史记录
          this.history.push({
            id: Date.now() + Math.random().toString(36).substr(2, 9),
            type: 'readGroup',
            groupId: request.groupId,
            result: groupValues,
            status: 'completed',
            timestamp: Date.now()
          });
          
          if (request.resolve) {
            request.resolve(groupValues);
          }
        } catch (err) {
          console.error(`❌ 分组 ${request.groupId} 读取失败:`, err);
          
          // 添加到历史记录
          this.history.push({
            id: Date.now() + Math.random().toString(36).substr(2, 9),
            type: 'readGroup',
            groupId: request.groupId,
            error: err.message,
            status: 'failed',
            timestamp: Date.now()
          });
          
          if (request.reject) {
            request.reject(err);
          }
        }
      }
      
      // 处理写入请求（按顺序处理）
      for (const request of writeRequests) {
        try {
          console.log(`📤 统一写入变量: ${request.variable} = ${request.value}`);
          const result = await this.writeVariableInternal(request.variable, request.value);
          
          // 添加到历史记录
          this.history.push({
            id: Date.now() + Math.random().toString(36).substr(2, 9),
            type: 'write',
            variable: request.variable,
            value: request.value,
            result: result,
            status: 'completed',
            timestamp: Date.now()
          });
          
          if (request.resolve) {
            request.resolve(result);
          }
        } catch (err) {
          console.error(`❌ 变量 ${request.variable} 写入失败:`, err);
          
          // 添加到历史记录
          this.history.push({
            id: Date.now() + Math.random().toString(36).substr(2, 9),
            type: 'write',
            variable: request.variable,
            value: request.value,
            error: err.message,
            status: 'failed',
            timestamp: Date.now()
          });
          
          if (request.reject) {
            request.reject(err);
          }
        }
      }
    } catch (err) {
      console.error('❌ 处理请求队列时发生错误:', err);
    } finally {
      this.isProcessing = false;
    }
  }

  // 添加读取请求到队列
  addReadRequestToQueue(variables) {
    return new Promise((resolve, reject) => {
      const request = {
        type: 'read',
        variables: variables,
        resolve: resolve,
        reject: reject
      };
      this.requestQueue.push(request);
    });
  }

  // 添加分组读取请求到队列
  addReadGroupRequestToQueue(groupId) {
    return new Promise((resolve, reject) => {
      const request = {
        type: 'readGroup',
        groupId: groupId,
        resolve: resolve,
        reject: reject
      };
      this.requestQueue.push(request);
    });
  }

  // 添加写入请求到队列
  addWriteRequestToQueue(variable, value) {
    return new Promise((resolve, reject) => {
      const request = {
        type: 'write',
        variable: variable,
        value: value,
        resolve: resolve,
        reject: reject
      };
      this.requestQueue.push(request);
    });
  }

  // 内部读取变量方法（不经过队列）
  async readVariablesInternal(vars) {
    // 添加更详细的连接状态检查和日志
    console.log('🔍 连接状态检查:', { 
      isConnected: this.isConnected, 
      hasConnector: !!this.connector,
      connectorConnected: this.connector ? this.connector.isConnected : 'no connector'
    });
    
    // 如果未连接或没有connector，尝试重新初始化连接
    if (!this.isConnected || !this.connector || !this.connector.isConnected) {
      console.warn('⚠️ PLC未连接，尝试重新初始化连接...');
      const reconnected = await this.init();
      
      if (!reconnected) {
        const error = new Error('PLC未连接且无法重新连接');
        console.error('❌ 读取变量失败:', error.message);
        console.error('🔍 当前连接状态详情:', { 
          isConnected: this.isConnected, 
          hasConnector: !!this.connector
        });
        throw error;
      }
    }
    
    try {
      console.log('📥 PLC服务正在读取变量:', vars);
      const result = await this.connector.readVariables(vars);
      console.log('✅ PLC服务读取变量成功:', result);
      return result;
    } catch (err) {
      console.error('❌ PLC服务读取变量失败:', err);
      
      // 如果是连接相关错误，尝试重新连接
      if (err.message.includes('PLC未连接') || err.message.includes('连接')) {
        console.warn('⚠️ 检测到连接错误，尝试重新初始化连接...');
        await this.init();
      }
      
      throw new Error(`读取变量失败: ${err.message}`);
    }
  }

  // 内部写入变量方法（不经过队列）
  async writeVariableInternal(name, value) {
    // 如果未连接或没有connector，尝试重新初始化连接
    if (!this.isConnected || !this.connector || !this.connector.isConnected) {
      console.warn('⚠️ PLC未连接，尝试重新初始化连接...');
      const reconnected = await this.init();
      
      if (!reconnected) {
        const error = new Error('PLC未连接且无法重新连接');
        console.error('❌ 写入变量失败:', error.message);
        throw error;
      }
    }
    
    try {
      console.log('📤 PLC服务正在写入变量:', name, '值:', value);
      
      // 数据类型转换和验证
      let convertedValue = value;
      
      // 如果是字符串，尝试转换为适当的数据类型
      if (typeof value === 'string') {
        // 检查是否为数字
        if (!isNaN(value) && !isNaN(parseFloat(value))) {
          // 检查是否为整数
          if (Number.isInteger(parseFloat(value)) && !value.includes('.')) {
            convertedValue = parseInt(value, 10);
          } else {
            convertedValue = parseFloat(value);
          }
        }
        // 检查是否为布尔值
        else if (value.toLowerCase() === 'true') {
          convertedValue = true;
        } else if (value.toLowerCase() === 'false') {
          convertedValue = false;
        }
        // 如果是空字符串，转换为0
        else if (value === '') {
          convertedValue = 0;
        }
      }
      
      console.log('🔄 转换后的值:', name, '值:', convertedValue, '类型:', typeof convertedValue);
      
      const result = await this.connector.writeVariable(name, convertedValue);
      console.log('✅ PLC服务写入变量成功:', name, '值:', convertedValue, '返回结果:', result);
      // 返回写入结果，确保包含成功状态
      return { success: true, name, value: convertedValue, result };
    } catch (err) {
      console.error('❌ PLC服务写入变量失败:', err);
      
      // 如果是连接相关错误，尝试重新连接
      if (err.message.includes('PLC未连接') || err.message.includes('连接')) {
        console.warn('⚠️ 检测到连接错误，尝试重新初始化连接...');
        await this.init();
      }
      
      // 抛出更详细的错误信息
      throw new Error(`写入变量失败: ${err.message}`);
    }
  }

  // 读取变量（通过统一队列处理）
  async readVariables(vars) {
    return await this.addReadRequestToQueue(vars);
  }

  // 读取指定分组的变量 - 新增方法（通过统一队列处理）
  async readGroupVariables(groupId) {
    return await this.addReadGroupRequestToQueue(groupId);
  }

  // 内部读取指定分组的变量方法（不经过队列）
  async readGroupVariablesInternal(groupId) {
    // 只加载指定的分组配置，而不是所有分组
    const group = await this.loadGroupFile(groupId);

    const variables = group.variables.map(v => v.address);
    return await this.readVariablesInternal(variables);
  }

  // 读取所有分组的变量 - 新增方法
  async readAllGroupVariables() {
    // 只在需要时加载所有分组配置
    if (!this.groups) {
      await this.loadAllGroups();
    }

    const allResults = {};
    for (const group of this.groups.groups) {
      try {
        const variables = group.variables.map(v => v.address);
        const result = await this.readVariablesInternal(variables);
        allResults[group.id] = {
          groupName: group.name,
          data: result
        };
      } catch (err) {
        console.error(`读取分组 ${group.name} 失败:`, err);
        allResults[group.id] = {
          groupName: group.name,
          error: err.message
        };
      }
    }
    return allResults;
  }

  // 写入变量 - 增强版本（通过统一队列处理）
  async writeVariable(name, value) {
    return await this.addWriteRequestToQueue(name, value);
  }

  // 写入分组中的变量 - 新增方法（通过统一队列处理）
  async writeGroupVariable(groupId, variableName, value) {
    try {
      // 检查变量名是否为空
      if (!variableName || typeof variableName !== 'string' || variableName.trim() === '') {
        throw new Error('变量名不能为空');
      }
      
      // 只加载指定的分组配置
      const group = await this.loadGroupFile(groupId);

      // 首先尝试通过名称查找变量
      let variable = group.variables.find(v => v.name === variableName);
      
      // 如果通过名称找不到，尝试通过地址查找
      if (!variable) {
        variable = group.variables.find(v => v.address === variableName);
      }
      
      // 如果都找不到，直接使用地址作为变量名进行写入
      const address = variable ? variable.address : variableName;

      return await this.writeVariable(address, value);
    } catch (err) {
      console.error(`❌ 写入分组 ${groupId} 变量 ${variableName} 失败:`, err);
      throw new Error(`写入分组变量失败: ${err.message}`);
    }
  }

  // 设置周期性读取
  setReadInterval(vars, interval) {
    // 如果未连接，先尝试连接
    if (!this.isConnected || !this.connector) {
      console.warn('⚠️ PLC未连接，设置周期性读取前将尝试连接...');
      this.init().then(connected => {
        if (connected) {
          this._setReadIntervalInternal(vars, interval);
        } else {
          console.error('❌ 无法设置周期性读取：PLC连接失败');
        }
      }).catch(err => {
        console.error('❌ 设置周期性读取时发生错误:', err);
      });
      return;
    }
    
    this._setReadIntervalInternal(vars, interval);
  }
  
  // 内部设置周期性读取方法
  _setReadIntervalInternal(vars, interval) {
    // 如果没有提供变量和间隔，使用配置文件中的默认值
    if (!vars && this.config && this.config.variables) {
      vars = this.config.variables.map(v => v.name);
    }
    
    if (!interval && this.config && this.config.readInterval) {
      interval = this.config.readInterval;
    }
    
    console.log(`🔄 设置PLC周期性读取，变量: ${vars ? vars.length : 0}个, 间隔: ${interval}ms`);
    this.connector.setReadInterval(vars, interval);
  }

  // 设置分组周期性读取 - 新增方法
  setGroupReadInterval(groupId, interval) {
    // 只加载指定的分组配置
    this.loadGroupFile(groupId).then(group => {
      const variables = group.variables.map(v => v.address);
      this.setReadInterval(variables, interval);
    }).catch(err => {
      console.error(`设置分组 ${groupId} 周期性读取失败:`, err);
    });
  }

  // 获取PLC配置
  getConfig() {
    return this.config;
  }

  // 获取分组配置 - 新增方法
  getGroups() {
    return this.groups;
  }

  // 保存PLC配置文件 - 新增方法
  async saveConfig(config) {
    try {
      const configPath = path.join(__dirname, '../public/plc-config.json');
      console.log('💾 正在保存PLC配置文件到:', configPath);
      console.log('💾 配置内容:', JSON.stringify(config, null, 2));
      
      // 确保目录存在
      const dirPath = path.dirname(configPath);
      try {
        await fs.access(dirPath);
      } catch (err) {
        // 目录不存在，创建目录
        await fs.mkdir(dirPath, { recursive: true });
      }
      
      await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf8');
      this.config = config;
      console.log('✅ PLC配置文件保存成功');
      return { success: true, message: '配置保存成功' };
    } catch (err) {
      console.error('❌ PLC配置文件保存失败:', err);
      return { success: false, message: `保存配置文件失败: ${err.message}` };
    }
  }

  // 保存分组配置文件 - 新增方法
  async saveGroupConfig(groupId, groupConfig) {
    try {
      const groupFilePath = path.join(__dirname, '../public/plc-groups', `${groupId}.json`);
      console.log(`💾 正在保存PLC分组配置文件 ${groupId} 到:`, groupFilePath);
      console.log(`💾 分组配置内容:`, JSON.stringify(groupConfig, null, 2));
      
      // 确保目录存在
      const dirPath = path.dirname(groupFilePath);
      try {
        await fs.access(dirPath);
      } catch (err) {
        // 目录不存在，创建目录
        await fs.mkdir(dirPath, { recursive: true });
      }
      
      await fs.writeFile(groupFilePath, JSON.stringify(groupConfig, null, 2), 'utf8');
      console.log(`✅ PLC分组配置文件 ${groupId} 保存成功`);
      return { success: true, message: '分组配置保存成功' };
    } catch (err) {
      console.error(`❌ PLC分组配置文件 ${groupId} 保存失败:`, err);
      return { success: false, message: `保存分组配置文件 ${groupId} 失败: ${err.message}` };
    }
  }

  // 另存为新的分组配置文件 - 新增方法
  async saveAsGroupConfig(groupId, groupConfig) {
    try {
      const groupFilePath = path.join(__dirname, '../public/plc-groups', `${groupId}.json`);
      console.log(`💾 正在另存为PLC分组配置文件 ${groupId} 到:`, groupFilePath);
      
      // 检查文件是否已存在
      try {
        await fs.access(groupFilePath);
        // 文件已存在，返回错误
        console.log(`⚠️ 分组配置文件 ${groupId}.json 已存在`);
        return { success: false, message: `分组配置文件 ${groupId}.json 已存在` };
      } catch (accessErr) {
        // 如果是文件不存在错误，继续保存
        if (accessErr.code !== 'ENOENT') {
          throw accessErr;
        }
      }
      
      // 确保目录存在
      const dirPath = path.dirname(groupFilePath);
      try {
        await fs.access(dirPath);
      } catch (err) {
        // 目录不存在，创建目录
        await fs.mkdir(dirPath, { recursive: true });
      }
      
      // 保存文件
      await fs.writeFile(groupFilePath, JSON.stringify(groupConfig, null, 2), 'utf8');
      console.log(`✅ PLC分组配置文件 ${groupId} 另存为成功`);
      
      // 更新分组文件列表
      await this.loadGroupFiles();
      
      return { success: true, message: '分组配置另存为成功' };
    } catch (err) {
      console.error(`❌ PLC分组配置文件 ${groupId} 另存为失败:`, err);
      return { success: false, message: `另存为分组配置文件 ${groupId} 失败: ${err.message}` };
    }
  }

  // 删除分组配置文件 - 新增方法
  async deleteGroupConfig(groupId) {
    try {
      const groupFilePath = path.join(__dirname, '../public/plc-groups', `${groupId}.json`);
      console.log(`🗑️ 正在删除PLC分组配置文件 ${groupId} 从:`, groupFilePath);
      
      // 检查文件是否存在
      try {
        await fs.access(groupFilePath);
      } catch (accessErr) {
        // 如果是文件不存在错误，返回错误
        if (accessErr.code === 'ENOENT') {
          console.log(`⚠️ 分组配置文件 ${groupId}.json 不存在`);
          return { success: false, message: `分组配置文件 ${groupId}.json 不存在` };
        } else {
          throw accessErr;
        }
      }
      
      // 删除文件
      await fs.unlink(groupFilePath);
      console.log(`✅ PLC分组配置文件 ${groupId} 删除成功`);
      
      // 更新分组文件列表
      await this.loadGroupFiles();
      
      return { success: true, message: '分组配置删除成功' };
    } catch (err) {
      console.error(`❌ PLC分组配置文件 ${groupId} 删除失败:`, err);
      return { success: false, message: `删除分组配置文件 ${groupId} 失败: ${err.message}` };
    }
  }

  // 断开连接
  disconnect() {
    console.log('🔌 正在断开PLC连接...');
    if (this.connector) {
      this.connector.disconnect();
      this.isConnected = false;
      console.log('✅ PLC连接已断开');
    } else {
      console.log('⚠️ 没有活动的PLC连接');
    }
    // 停止处理循环
    this.stopProcessingLoop();
  }
  
  // 强制重新连接
  async reconnect() {
    console.log('🔄 强制重新连接PLC...');
    return this.init();
  }
  
  // 获取连接状态详细信息
  getConnectionStatus() {
    return {
      isConnected: this.isConnected,
      hasConnector: !!this.connector,
      connectorConnected: this.connector ? this.connector.isConnected : 'no connector',
      reconnectAttempts: this.connector ? this.connector.reconnectAttempts : 0
    };
  }

  // 获取PLC内部队列状态 - 新增方法
  getQueueStatus() {
    return {
      queueLength: this.requestQueue.length,
      processing: this.isProcessing,
      pendingTasks: this.requestQueue.map(item => ({
        type: item.type,
        variables: item.variables || item.variable,
        groupId: item.groupId,
        timestamp: Date.now()
      }))
    };
  }

  // 获取PLC内部队列历史记录 - 修改方法
  getQueueHistory() {
    // 返回最近的100条记录，按时间倒序排列（最新的在最上面）
    const recentHistory = this.history.slice(-100);
    return recentHistory.reverse();
  }
}

module.exports = new PLCService();